#!/usr/bin/env node

const fs = require('fs');
const path = require('path');

/**
 * 智能日志清理脚本
 * 支持按时间、大小和文件类型清理日志文件
 * 保留重要的错误日志
 */

const logsDir = path.join(__dirname, '../logs');

// 清理配置
const CLEANUP_CONFIG = {
  maxFileAge: 7 * 24 * 60 * 60 * 1000,  // 7天（毫秒）
  maxFileSize: 50 * 1024 * 1024,        // 50MB
  preserveErrorLogs: true,               // 保留错误日志
  preserveRecentLogs: 24 * 60 * 60 * 1000, // 保留最近24小时的日志
};

function clearLogs(options = {}) {
  const config = { ...CLEANUP_CONFIG, ...options };
  console.log('🧹 开始智能清理日志文件...');
  console.log(`📋 清理策略: 文件保留${Math.ceil(config.maxFileAge / (24 * 60 * 60 * 1000))}天, 最大${formatBytes(config.maxFileSize)}`);

  if (!fs.existsSync(logsDir)) {
    console.log('📁 日志目录不存在，无需清理');
    return;
  }

  try {
    const stats = smartClearDirectory(logsDir, config);
    console.log('✅ 日志文件清理完成！');
    console.log(`📊 统计: 清理 ${stats.deletedFiles} 个文件，释放空间 ${formatBytes(stats.freedSpace)}`);
    console.log(`📁 保留 ${stats.preservedFiles} 个重要文件`);
  } catch (error) {
    console.error('❌ 清理日志文件时出错:', error.message);
    process.exit(1);
  }
}

/**
 * 智能清理目录
 */
function smartClearDirectory(dirPath, config) {
  const stats = {
    deletedFiles: 0,
    freedSpace: 0,
    preservedFiles: 0
  };

  const now = Date.now();

  function processDirectory(currentPath) {
    if (!fs.existsSync(currentPath)) {
      return;
    }

    const files = fs.readdirSync(currentPath);

    files.forEach(file => {
      const filePath = path.join(currentPath, file);
      const stat = fs.statSync(filePath);

      if (stat.isDirectory()) {
        // 递归处理子目录
        processDirectory(filePath);
      } else if (stat.isFile() && file.endsWith('.log')) {
        const fileAge = now - stat.mtime.getTime();
        const fileSize = stat.size;
        const isErrorLog = file.includes('error') || file.includes('err');
        const isRecentLog = fileAge < config.preserveRecentLogs;

        // 智能清理决策
        const shouldPreserve =
          (isErrorLog && config.preserveErrorLogs) ||  // 保留错误日志
          isRecentLog ||                               // 保留最近的日志
          file.includes('common-error');               // 保留通用错误日志

        const shouldDelete =
          !shouldPreserve && (
            fileAge > config.maxFileAge ||             // 文件太旧
            fileSize > config.maxFileSize ||           // 文件太大
            file.includes('debug') ||                  // 调试日志
            file.includes('info')                      // 信息日志
          );

        if (shouldDelete) {
          try {
            fs.unlinkSync(filePath);
            stats.deletedFiles++;
            stats.freedSpace += fileSize;
            console.log(`🗑️  删除日志文件: ${file} (${formatBytes(fileSize)}, ${formatAge(fileAge)})`);
          } catch (err) {
            console.warn(`⚠️  删除文件失败: ${file}`, err.message);
          }
        } else {
          stats.preservedFiles++;
          if (shouldPreserve) {
            console.log(`📌 保留重要日志: ${file} (${formatBytes(fileSize)})`);
          }
        }
      }
    });
  }

  processDirectory(dirPath);
  return stats;
}

/**
 * 格式化字节数
 */
function formatBytes(bytes) {
  if (bytes === 0) return '0 Bytes';

  const k = 1024;
  const sizes = ['Bytes', 'KB', 'MB', 'GB'];
  const i = Math.floor(Math.log(bytes) / Math.log(k));

  return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + ' ' + sizes[i];
}

/**
 * 格式化时间差
 */
function formatAge(milliseconds) {
  const seconds = Math.floor(milliseconds / 1000);
  const minutes = Math.floor(seconds / 60);
  const hours = Math.floor(minutes / 60);
  const days = Math.floor(hours / 24);

  if (days > 0) return `${days}天前`;
  if (hours > 0) return `${hours}小时前`;
  if (minutes > 0) return `${minutes}分钟前`;
  return `${seconds}秒前`;
}

// 兼容旧版本的函数
function clearDirectory(dirPath) {
  console.log('⚠️  使用旧版清理方式，建议升级到智能清理');
  smartClearDirectory(dirPath, CLEANUP_CONFIG);
}

// 如果直接运行此脚本
if (require.main === module) {
  clearLogs();
}

module.exports = clearLogs;
